home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 4: GNU Archives / Linux Cubed Series 4 - GNU Archives.iso / gnu / fontutil.6 / fontutil / fontutils-0.6 / charspace / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-23  |  10.3 KB  |  328 lines
  1. /* charspace -- find intercharacter spacing based on user information.
  2.  
  3. Copyright (C) 1992 Free Software Foundation, Inc.
  4.  
  5. This program is free software; you can redistribute it and/or modify
  6. it under the terms of the GNU General Public License as published by
  7. the Free Software Foundation; either version 2, or (at your option)
  8. any later version.
  9.  
  10. This program is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. GNU General Public License for more details.
  14.  
  15. You should have received a copy of the GNU General Public License
  16. along with this program; if not, write to the Free Software
  17. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  18.  
  19. #include "config.h"
  20.  
  21. #include "cmdline.h"
  22. #include "encoding.h"
  23. #include "font.h"
  24. #include "getopt.h"
  25. #include "report.h"
  26.  
  27. #include "char.h"
  28. #include "input-cmi.h"
  29. #include "main.h"
  30. #include "output.h"
  31. #include "symtab.h"
  32.  
  33. /* Must come after `symtab.h', since it uses `symval_type'.  (It's
  34.    generated by Bison, so we can't fix it.)  */
  35. #include "cmi.h"
  36.  
  37.  
  38. /* The resolution of the font we will read, in pixels per inch.  We
  39.    don't deal with nonsquare pixels.  (-dpi)  */
  40. string dpi = "300";
  41. real dpi_real;
  42.  
  43. /* The name of the encoding file specified by the user, and the
  44.    structure we parse it into.  (-encoding)  */
  45. static string encoding_name = NULL;
  46. encoding_info_type encoding_info;
  47.  
  48. /* Whether or not there was a TFM file corresponding to `input_name'.
  49.   If true, `tfm_get_char' can be called -- otherwise not.  */
  50. boolean have_tfm = false;
  51.  
  52. /* The name of the bitmap font we input.  */
  53. string input_name;
  54.  
  55. /* Whether or not to output a GF file.  (-no-gf) */
  56. boolean no_gf = false;
  57.  
  58. /* Says which characters we should process.  This is independent of the
  59.    ordering in the font file.  (-range)  */
  60. charcode_type starting_char = 0;
  61. charcode_type ending_char = MAX_CHARCODE;
  62.  
  63.  
  64. static string read_command_line (int, string[]);
  65. static encoding_info_type read_encoding_info (string);
  66. static string *scan_string_list (string);
  67.  
  68. /* Charspace computes side bearing values to put in a font.  It doesn't
  69.    do so automatically, unfortunately: auxiliary files have to specify
  70.    everything.  The basic idea is due to Harry Carter as described in
  71.    Walter Tracy's book (see README for the citation): space a few of the
  72.    letters (O, H, o, n) by hand amongst themselves.  Then a reasonable
  73.    value for most of the other side bearings can be determined
  74.    (independent of the typeface) as a percentage of those ``control
  75.    letters'' sidebearings.
  76.    
  77.    The basic strategy is to first read `common.cmi', which specifies the
  78.    font-independent side bearing apportionments.  Then we read
  79.    font-specific CMI files to actually define the side bearing values,
  80.    specify kerns, and so on.
  81.    
  82.    This defines a whole bunch of things in the symbol table (see
  83.    `symtab.c').  We then resolve the side bearing information for all
  84.    the characters we will output, after all the definitions have been
  85.    read.
  86.    
  87.    Then we output the revised GF and TFM files.  We read an existing TFM
  88.    file and an encoding file, as well as accepting various options, to
  89.    get lig/kern and other TFM information.  */
  90.    
  91. int
  92. main (int argc, string argv[])
  93. {
  94.   /* This is static only because we want it to be initialized entirely
  95.      to NULL pointers, and it's too painful to write out 256 NULL's.  */
  96.   static char_type *chars[MAX_CHARCODE + 1];
  97.   unsigned code;
  98.   bitmap_font_type font;
  99.   string font_rootname;
  100.   string tfm_name;
  101.  
  102.   /* Get the bitmap font we're reading.  */
  103.   input_name = read_command_line (argc, argv);
  104.   font = get_bitmap_font (input_name, atou (dpi));
  105.   font_rootname = remove_suffix (basename (input_name));
  106.  
  107.   /* Make sure the output name is ok.  */
  108.   if (output_name == NULL)
  109.     output_name = input_name;
  110.  
  111.   if (!no_gf && find_suffix (output_name) != NULL)
  112.     FATAL ("You can't specify a suffix and more than one output file");
  113.  
  114.   tfm_name = find_tfm_filename (input_name);
  115.   if (tfm_name != NULL)
  116.     {
  117.       if (!tfm_open_input_file (tfm_name))
  118.         FATAL1 ("%s: Could not open TFM file", tfm_name);
  119.       else
  120.         have_tfm = true;
  121.     }
  122.  
  123.   /* Set the numeric counterpart of `dpi', for use in lots of places. */
  124.   dpi_real = atof (dpi);
  125.   
  126.   /* If the user didn't specify CMI files to read, then use
  127.      `<input_name>.<dpi>cmi'.  */
  128.   if (cmi_names == NULL)
  129.     cmi_names = scan_string_list (input_name);
  130.  
  131.   /* Define the designsize, so the CMI files can refer to it.  */
  132.   {
  133.     real ds_points = BITMAP_FONT_DESIGN_SIZE (font);
  134.     real ds_pixels = POINTS_TO_REAL_PIXELS (ds_points, dpi_real);
  135.     symtab_define ("designsize", symtab_real_node (ds_pixels));
  136.   }
  137.  
  138.   /* Read all the CMI information.  */
  139.   read_cmi_file ("common.cmi", "");
  140.   read_cmi_file_list (cmi_names, dpi);
  141.   
  142.   /* Figure out the font encoding scheme.  Must be done after reading
  143.      the CMI files, since they can specify the codingscheme.  */
  144.   encoding_info = read_encoding_info (encoding_name);
  145.   
  146.   /* The main loop: compute each character's information.  */
  147.   for (code = starting_char; code <= ending_char; code++)
  148.     {
  149.       do_char (code, &chars[code]);
  150.     }
  151.  
  152.   /* Output what we've so laboriously collected.  */
  153.   output_font (font, chars);
  154.  
  155.   close_font (input_name);
  156.   if (have_tfm)
  157.     tfm_close_input_file ();
  158.     
  159.   return 0;
  160. }
  161.  
  162. /* Return the font encoding.  Use
  163.    1) USER_NAME (if it's non-null);
  164.    2) the value of `codingscheme' in the symbol table (if it's a string);
  165.    3) the codingscheme from an existing TFM file (if we have one).
  166.    
  167.    Otherwise, give a fatal error.  */
  168.  
  169. static encoding_info_type
  170. read_encoding_info (string user_name)
  171. {
  172.   encoding_info_type ei;
  173.   
  174.   if (user_name != NULL)
  175.     ei = read_encoding_file (user_name);
  176.   else
  177.     {
  178.       string enc_name;
  179.       string codingscheme = NULL;
  180.       symval_type *sv = symtab_lookup ("codingscheme");
  181.  
  182.       if (sv == NULL)
  183.         codingscheme = have_tfm ? tfm_get_coding_scheme () : DEFAULT_ENCODING;
  184.  
  185.       else if (SYMVAL_TAG (*sv) == symval_string)
  186.         codingscheme = SYMVAL_STRING (*sv);
  187.       
  188.       else
  189.         FATAL ("codingscheme: defined (in CMI file) as a non-string");
  190.       
  191.       assert (codingscheme != NULL);
  192.       
  193.       enc_name = coding_scheme_to_filename (codingscheme);
  194.       ei = read_encoding_file (enc_name);
  195.     }
  196.   
  197.   return ei;
  198. }
  199.  
  200. /* Reading the options.  */
  201.  
  202. /* This is defined in version.c.  */
  203. extern string version_string;
  204.  
  205. #define USAGE "Options:
  206. <font_name> should be a filename, possibly with a resolution, e.g.,
  207.   `cmr10' or `cmr10.300'.\n"                        \
  208.   GETOPT_USAGE                                \
  209. "cmi-files <file1>,<file2>,...: read the CMI files
  210.   `<file1>.<dpi>cmi', `<file2>.<dpi>cmi', etc., after reading
  211.   `common.cmi'; default is `<font-name>.<dpi>cmi'.  The <dpi>cmi is not
  212.   appended to any of the <file>s which already have a suffix.
  213. dpi <unsigned>: use this resolution; default is 300.
  214. encoding <filename>: read ligature and other encoding information
  215.   from <filename>.enc; there is no default.  (A TFM file <font-name>.tfm
  216.   is also read, if it exists.)
  217. fontdimens <fontdimen>:<real>,<fontdimen>:<real>,...: assign <value>
  218.   to each <fontdimen> given, when outputting a TFM file.  A <fontdimen>
  219.   can be either one of the standard names (in either upper or
  220.   lowercase), or a number between 1 and 30.  Each <real> is taken to be
  221.   in points (except in the case of the <fontdimen> `SLANT' (parameter
  222.   1), which is a dimensionless number).
  223. no-gf: don't output a GF file.
  224. output-file <filename>: write the TFM file to `<filename>.tfm' and the
  225.   GF file to `<filename>.<dpi>gf'; <filename> shouldn't have a suffix;
  226.   default is <font-name>.tfm and <font-name>.<dpi>gf, or, if those would
  227.   overwrite the input, those preceded by `x'.
  228. range <char1>-<char2>: only process characters between <char1> and
  229.   <char2>, inclusive. 
  230. verbose: print brief progress reports on stdout.
  231. version: print the version number of this program.
  232. xheight-char <charcode>: use the height of this character as the
  233.   default x-height (for the TFM output); default is 120 (ASCII `x').
  234. "
  235.  
  236. static string
  237. read_command_line (int argc, string argv[])
  238. {
  239.   int g;   /* `getopt' return code.  */
  240.   int option_index;
  241.   boolean explicit_dpi = false;
  242.   boolean printed_version = false;
  243.   struct option long_options[]
  244.     = { { "dpi",        1, 0, 0 },
  245.         { "cmi-files",        1, 0, 0 },
  246.         { "encoding",        1, 0, 0 },
  247.         { "fontdimens",        1, 0, 0 },
  248.         { "help",               0, 0, 0 },
  249.         { "no-gf",        0, (int *) &no_gf, 1 },
  250.         { "output-file",    1, 0, 0 },
  251.         { "range",        1, 0, 0 },
  252.         { "verbose",        0, (int *) &verbose, 1 },
  253.         { "version",        0, (int *) &printed_version, 1 },
  254.         { "xheight-char",    1, 0, 0 },
  255.         { 0, 0, 0, 0 } };
  256.   
  257.   while (true)
  258.     {
  259.       g = getopt_long_only (argc, argv, "", long_options, &option_index);
  260.       
  261.       if (g == EOF)
  262.         break;
  263.  
  264.       if (g == '?')
  265.         continue;  /* Unknown option.  */
  266.   
  267.       assert (g == 0); /* We have no short option names.  */
  268.   
  269.       if (ARGUMENT_IS ("cmi-files"))
  270.         cmi_names = scan_string_list (optarg);
  271.  
  272.       else if (ARGUMENT_IS ("dpi"))
  273.         dpi = optarg;
  274.       
  275.       else if (ARGUMENT_IS ("encoding"))
  276.         encoding_name = optarg;
  277.  
  278.       else if (ARGUMENT_IS ("fontdimens"))
  279.         fontdimens = optarg;
  280.  
  281.       else if (ARGUMENT_IS ("help"))
  282.         {
  283.           fprintf (stderr, "Usage: %s [options] <font_name>.\n", argv[0]);
  284.           fprintf (stderr, USAGE);
  285.           exit (0);
  286.         }
  287.  
  288.       else if (ARGUMENT_IS ("output-file"))
  289.         output_name = optarg;
  290.  
  291.       else if (ARGUMENT_IS ("range"))
  292.         GET_RANGE (optarg, starting_char, ending_char);
  293.       
  294.       else if (ARGUMENT_IS ("version"))
  295.         printf ("%s.\n", version_string);
  296.       
  297.       else if (ARGUMENT_IS ("xheight-char"))
  298.         xheight_char = xparse_charcode (optarg);
  299.         
  300.       /* Else it was just a flag; getopt has already done the assignment.  */
  301.     }
  302.   
  303.   FINISH_COMMAND_LINE ();
  304. }
  305.  
  306.  
  307. /* Take a string L consisting of unsigned strings separated by commas
  308.    and return a vector of the strings, as pointers. 
  309.    Append an element to the vector.  */
  310.  
  311. static string *
  312. scan_string_list (string l)
  313. {
  314.   string map;
  315.   unsigned length = 1;
  316.   string *vector = xmalloc (sizeof (string));
  317.   
  318.   for (map = strtok (l, ","); map != NULL; map = strtok (NULL, ","))
  319.     {
  320.       length++;
  321.       vector = xrealloc (vector, length * sizeof (string));
  322.       vector[length - 2] = map;
  323.     }
  324.   
  325.   vector[length - 1] = NULL;
  326.   return vector;
  327. }
  328.